{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Q-Network Variant NoisyNet DQN implementation (PyTorch).\n",
    "\n",
    "In this notebook, we will implement NoisyNet DQN variant of DQN. First part of the notebook is all about the vanilla DQN and how we train - a copy of `6_a_dqn_pytorch.ipynb`. The C51 DQN variant is after these sections on vanilla DQN. \n",
    "\n",
    "\n",
    "### RECAP\n",
    "\n",
    "Q Learning control is carried out by sampling step by step and updating Q values at each step. We use $\\epsilon$-greedy policy to explore and generate samples. However, the policy learnt is a deterministic greedy policy with no exploration. We can carryout updates online i.e. we take a step and use `(current state, action, reward and next_state)` tuple to update.\n",
    "\n",
    "In case of function approximation using neural network, the input to the network is the state and output is the $q(s,a)$ for all the actions in the state $s$. It is denoted as $ \\hat{q}(s_t, a_t; w_{t}) $, where $w_{t}$ is the weigths of the neural network that we learn as part of DQN learning.\n",
    "\n",
    "We use two networks, one target network with weight $w^-_t$ to get the max $q$-value of next state with best action denoted by $ \\max\\limits_a \\hat {q}(S_{t+1},a; w^{-}_{t}) $ and network with weights $w_t^-$ which we periodically updated from primary network $w_t$.\n",
    "\n",
    "The Update equation is given below. This is the online version:\n",
    "$$ w_{t+1} \\leftarrow w_t + \\alpha [ R_{t+1} + \\gamma . \\max_{a} \\hat{q}(S_{t+1},a;w^{-}_{t}) – \\hat{q}(S_t,A_t;w_t)] \\nabla_{w_t} \\hat{q}(S_t,A_t;w_t)$$\n",
    "\n",
    "Online update with neural network with millions of weights does not work well. Accordingly, We use experience replay (aka Replay Buffer).  We use a behavior policy to explore the environment and store the samples `(s, a, r, s', done)` in a buffer. The samples are generated using an exploratory behavior policy while we improve a deterministic target policy using q-values.\n",
    "\n",
    "Therefore, we can always use older samples from behavior policy and apply them again and again. We can keep the buffer size fixed to some pre-determined size and keep deleting the older samples as we collect new ones. This process makes learning sample efficient by reusing a sample multiple times and also removing temporal dependence of the samples we would otherwise see while following a trajectory.\n",
    "\n",
    "The update equation with batch update with minor modifications is given below. We collect samples of transitions `(current state, action, reward, next state)` in a buffer, where each sample is denoted as a tuple:\n",
    "\n",
    "$$ (s_{i}, a_{i}, r_{i}, s'_{i}, done_{i})$$\n",
    "\n",
    "Subscript ($i$) denotes ith sample. We take $N$ samples from experience replay selecting randomly and update the weights. Subscript ($t$) denotes the index of weight updates. If the current state is done, as denoted by `done` flag, the target is just the reward as terminal states have zero value. The final update equation is as given below:\n",
    "\n",
    "$$w_{t+1} \\leftarrow w_t + \\alpha \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_{i},a';w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla_{w_t} \\hat{q}(s_i,a_i;w_t)$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Running in Colab/Kaggle\n",
    "\n",
    "If you are running this on Colab, please uncomment below cells and run this to install required dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Uncomment and execute this cell to install all the the dependencies if running in Google Colab\n",
    "\n",
    "# !apt-get update && apt-get install swig cmake ffmpeg freeglut3-dev xvfb\n",
    "# !pip install box2d-py\n",
    "# !pip install \"stable-baselines3[extra]>=2.1\"\n",
    "# !pip install \"huggingface_sb3>=3.0\"\n",
    "\n",
    "# !pip install git+https://github.com/DLR-RM/rl-baselines3-zoo@update/hf\n",
    "# !git clone https://github.com/DLR-RM/rl-baselines3-zoo\n",
    "# %cd rl-baselines3-zoo/\n",
    "# !pip install -r requirements.txt\n",
    "# %cd ..\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-14 13:54:31.501513: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2023-12-14 13:54:31.505473: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2023-12-14 13:54:31.572481: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2023-12-14 13:54:31.572531: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2023-12-14 13:54:31.572561: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2023-12-14 13:54:31.582164: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2023-12-14 13:54:31.584068: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-12-14 13:54:33.267563: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import math\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import convolve, gaussian\n",
    "from stable_baselines3.common.vec_env import VecVideoRecorder, DummyVecEnv\n",
    "from base64 import b64encode\n",
    "import time\n",
    "from tqdm import trange\n",
    "import glob\n",
    "from collections import namedtuple\n",
    "\n",
    "from IPython.display import HTML, clear_output\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment - CartPole \n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are discrete. We will build it on Cart Pole. Readers can try to run this on many other environments like Lunar Lander and others."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_env(env_name):\n",
    "    # increase time limit from 200/500 to 4000\n",
    "    env = gym.make(env_name, render_mode=\"rgb_array\", max_episode_steps=4000)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state shape:(4,)\n",
      "Number of Actions:2\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "env_name = 'CartPole-v1'\n",
    "seed=123\n",
    "\n",
    "env = make_env(env_name)\n",
    "env.reset(seed=seed)\n",
    "plt.imshow(env.render())\n",
    "state_shape, n_actions = env.observation_space.shape, env.action_space.n\n",
    "print(f\"state shape:{state_shape}\\nNumber of Actions:{n_actions}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building a network using pytorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us build a DQN agent using a simple network. We now need to build a neural network that can map states/observations to state q-values. The observation space and action space is as given below for CartPole\n",
    "\n",
    "    Observation:\n",
    "        Type: Box(4)\n",
    "        Num     Observation               Min                     Max\n",
    "        0       Cart Position             -4.8                    4.8\n",
    "        1       Cart Velocity             -Inf                    Inf\n",
    "        2       Pole Angle                -0.418 rad (-24 deg)    0.418 rad (24 deg)\n",
    "        3       Pole Angular Velocity     -Inf                    Inf\n",
    "    Actions:\n",
    "        Type: Discrete(2)\n",
    "        Num   Action\n",
    "        0     Push cart to the left\n",
    "        1     Push cart to the right\n",
    "        \n",
    "\n",
    "The model will be a simple one with 2 hidden payers with Relu activation and final layer being logits with dimension equation to number of actions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent(nn.Module):\n",
    "    def __init__(self, state_shape, n_actions, epsilon=0):\n",
    "\n",
    "        super().__init__()\n",
    "        self.epsilon = epsilon\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape\n",
    "        \n",
    "        state_dim = state_shape[0]\n",
    "        # a simple NN with state_dim as input vector (input is state s)\n",
    "        # and self.n_actions as output vector of logits of q(s, a)\n",
    "        self.fc1 = nn.Linear(state_dim, 64)\n",
    "        self.fc2 = nn.Linear(64, 128)\n",
    "        self.fc3 = nn.Linear(128, 32)\n",
    "        self.q = nn.Linear(32, n_actions)\n",
    "        \n",
    "    def forward(self, state_t):\n",
    "        # pass the state at time t through the network to get Q(s,a)\n",
    "        x = F.relu(self.fc1(state_t))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = F.relu(self.fc3(x))\n",
    "        qvalues = self.q(x)\n",
    "        return qvalues\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        # input is an array of states in numpy and output is Qvals as numpy array\n",
    "        states = torch.tensor(states, device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        return qvalues.data.cpu().numpy()\n",
    "\n",
    "    def get_action(self, states):\n",
    "        states = torch.tensor(np.array(states), device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        return best_actions\n",
    "        \n",
    "    def sample_actions(self, qvalues):\n",
    "        # sample actions from a batch of q_values using epsilon greedy policy\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions = qvalues.shape\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        should_explore = np.random.choice(\n",
    "            [0, 1], batch_size, p=[1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = DQNAgent(state_shape, n_actions, epsilon=0.5).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(env, agent, n_games=1, greedy=False, t_max=10000):\n",
    "    rewards = []\n",
    "    for _ in range(n_games):\n",
    "        s,_ = env.reset(seed=seed)\n",
    "        reward = 0\n",
    "        for _ in range(t_max):\n",
    "            qvalues = agent.get_qvalues([s])\n",
    "            action = qvalues.argmax(axis=-1)[0] if greedy else agent.sample_actions(qvalues)[0]\n",
    "            s, r, termiated, truncated,_ = env.step(action)\n",
    "            reward += r\n",
    "            if termiated:\n",
    "                break\n",
    "\n",
    "        rewards.append(reward)\n",
    "    return np.mean(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "49.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1591/1482465590.py:27: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ../torch/csrc/utils/tensor_new.cpp:261.)\n",
      "  states = torch.tensor(states, device=device, dtype=torch.float32)\n"
     ]
    }
   ],
   "source": [
    "print(evaluate(env, agent, n_games=1))\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experience replay\n",
    "\n",
    "We will use the replay buffer we saw in chapter 4 listings. Replay buffer is very important in DQN to break the correlation between samples. We use a behavior policy ($\\epsilon$-greedy) to sample from the environment and store the transitions `(s,a,r,s',done)` into a buffer. These samples are used multiple times in a learning making the process sample efficient.\n",
    "\n",
    "The interface to ReplayBuffer is:\n",
    "* `exp_replay.add(state, action, reward, next_state, done)` - saves (s,a,r,s',done) tuple into the buffer\n",
    "* `exp_replay.sample(batch_size)` - returns states, actions, rewards, next_states and done_flags for `batch_size` random samples.\n",
    "* `len(exp_replay)` - returns number of elements stored in replay buffer.\n",
    "\n",
    "We have modified the implementation a bit to make it more efficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, size):\n",
    "        self.size = size #max number of items in buffer\n",
    "        self.buffer =[] #array to holde buffer\n",
    "        self.next_id = 0\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "    \n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        item = (state, action, reward, next_state, done)\n",
    "        if len(self.buffer) < self.size:\n",
    "           self.buffer.append(item)\n",
    "        else:\n",
    "            self.buffer[self.next_id] = item\n",
    "        self.next_id = (self.next_id + 1) % self.size\n",
    "        \n",
    "    def sample(self, batch_size):\n",
    "        idxs = np.random.choice(len(self.buffer), batch_size)\n",
    "        samples = [self.buffer[i] for i in idxs]\n",
    "        states, actions, rewards, next_states, done_flags = list(zip(*samples))\n",
    "        return np.array(states), np.array(actions), np.array(rewards), np.array(next_states), np.array(done_flags)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_and_record(start_state, agent, env, exp_replay, n_steps=1):\n",
    "\n",
    "    s = start_state\n",
    "    sum_rewards = 0\n",
    "\n",
    "    # Play the game for n_steps and record transitions in buffer\n",
    "    for _ in range(n_steps):\n",
    "        qvalues = agent.get_qvalues([s])\n",
    "        a = agent.sample_actions(qvalues)[0]\n",
    "        next_s, r, terminated, truncated, _ = env.step(a)\n",
    "        sum_rewards += r\n",
    "        done = terminated or truncated\n",
    "        exp_replay.add(s, a, r, next_s, done)\n",
    "        if done:\n",
    "            s,_ = env.reset()\n",
    "        else:\n",
    "            s = next_s\n",
    "\n",
    "    return sum_rewards, s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Target network\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target_network = DQNAgent(agent.state_shape, agent.n_actions, epsilon=0.5).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning with DQN\n",
    "Here we write a function similar to tabular q-learning. We will calculate average TD error per batch using the equation:\n",
    "\n",
    "$$ L =  \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_i,a';w^-_t) \\right) – \\hat{q}_{w_t}(s_i,a_i;w_t) \\right]^2$$\n",
    "\n",
    "\n",
    "$$ \\nabla_{w_t} L =   - \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_i,a';w^-_t) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}_{w_t}(s_i,a_i;w_t)$$\n",
    "\n",
    "\n",
    "$\\hat{q}(s',a';w^{-})$ is calculated using target network whose weights are held constant and refreshed periodically from the agent learning network.\n",
    "\n",
    "Target is given by following:\n",
    "* non terminal state: $r_i +  \\gamma .  \\max\\limits_{a'} \\hat{q}(s'_i,a';w^-_t)$\n",
    "* terminal state: $ r_i $\n",
    "\n",
    "We then carryout back propagation through the agent network to update the weights using equation below:\n",
    "\n",
    "\n",
    "$$\n",
    "w_{t+1} \\leftarrow w_t - \\alpha . \\nabla_{w_t}L$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def td_loss_dqn(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma=0.99, device=device):\n",
    "\n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, device=device, dtype=torch.float)\n",
    "    actions = torch.tensor(actions, device=device, dtype=torch.long)\n",
    "    rewards = torch.tensor(rewards, device=device, dtype=torch.float)\n",
    "    next_states = torch.tensor(next_states, device=device, dtype=torch.float)\n",
    "    done_flags = torch.tensor(done_flags.astype('float32'),device=device,dtype=torch.float)\n",
    "\n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    predicted_qvalues = agent(states)\n",
    "\n",
    "    # compute q-values for all actions in next states\n",
    "    # use target network\n",
    "    predicted_next_qvalues = target_network(next_states)\n",
    "\n",
    "    # select q-values for chosen actions\n",
    "    predicted_qvalues_for_actions = predicted_qvalues[range(\n",
    "        len(actions)), actions]\n",
    "\n",
    "    # compute Qmax(next_states, actions) using predicted next q-values\n",
    "    next_state_values,_ = torch.max(predicted_next_qvalues, dim=1)\n",
    "\n",
    "    # compute \"target q-values\"\n",
    "    target_qvalues_for_actions = rewards + gamma * next_state_values * (1-done_flags)\n",
    "\n",
    "    # mean squared error loss to minimize\n",
    "    loss = torch.mean((predicted_qvalues_for_actions -\n",
    "                       target_qvalues_for_actions.detach()) ** 2)\n",
    "\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def epsilon_schedule(start_eps, end_eps, step, final_step):\n",
    "    return start_eps + (end_eps-start_eps)*min(step, final_step)/final_step\n",
    "\n",
    "def smoothen(values):\n",
    "    kernel = gaussian(100, std=100)\n",
    "    kernel = kernel / np.sum(kernel)\n",
    "    return convolve(values, kernel, 'valid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main loop\n",
    "\n",
    "We now carryout the training on DQN setup above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set up Environment and Policy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#setup env and agent and target networks\n",
    "env_name = 'CartPole-v1'\n",
    "env = make_env(env_name)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "state,_ = env.reset(seed=seed)\n",
    "\n",
    "agent = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train agent function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_agent(env, agent, target_network, optimizer, td_loss_fn):\n",
    "    \n",
    "    state, _  = env.reset(seed=seed)\n",
    "    # let us fill experience replay with some samples using full random policy\n",
    "    exp_replay = ReplayBuffer(10**4)\n",
    "    for i in range(100):\n",
    "        play_and_record(state, agent, env, exp_replay, n_steps=10**2)\n",
    "        if len(exp_replay) == 10**4:\n",
    "            break\n",
    "    print('Finished filling buffer with: {} samples'.format(len(exp_replay)))\n",
    "\n",
    "    mean_rw_history = []\n",
    "    td_loss_history = []\n",
    "    state, _ = env.reset(seed=seed)\n",
    "    for step in trange(total_steps + 1):\n",
    "\n",
    "        # reduce exploration as we progress\n",
    "        agent.epsilon = epsilon_schedule(start_epsilon, end_epsilon, step, eps_decay_final_step)\n",
    "\n",
    "        # take timesteps_per_epoch and update experience replay buffer\n",
    "        _, state = play_and_record(state, agent, env, exp_replay, timesteps_per_epoch)\n",
    "\n",
    "        # train by sampling batch_size of data from experience replay\n",
    "        states, actions, rewards, next_states, done_flags = exp_replay.sample(batch_size)\n",
    "\n",
    "\n",
    "        # loss = <compute TD loss>\n",
    "        optimizer.zero_grad()\n",
    "        loss = td_loss_fn(agent, target_network, \n",
    "                          states, actions, rewards, next_states, done_flags,                  \n",
    "                          gamma=0.99,\n",
    "                          device=device)\n",
    "\n",
    "        loss.backward()\n",
    "        grad_norm = nn.utils.clip_grad_norm_(agent.parameters(), max_grad_norm)\n",
    "        optimizer.step()\n",
    "\n",
    "        if step % loss_freq == 0:\n",
    "            td_loss_history.append(loss.data.cpu().item())\n",
    "\n",
    "        if step % refresh_target_network_freq == 0:\n",
    "            # Load agent weights into target_network\n",
    "            target_network.load_state_dict(agent.state_dict())\n",
    "\n",
    "        if step % eval_freq == 0:\n",
    "            # eval the agent\n",
    "            mean_rw_history.append(evaluate(\n",
    "                make_env(env_name), agent, n_games=3, greedy=True, t_max=1000)\n",
    "            )\n",
    "\n",
    "            clear_output(True)\n",
    "            print(\"buffer size = %i, epsilon = %.5f\" %\n",
    "                  (len(exp_replay), agent.epsilon))\n",
    "\n",
    "            plt.figure(figsize=[16, 5])\n",
    "            plt.subplot(1, 2, 1)\n",
    "            plt.title(\"Mean return per episode\")\n",
    "            plt.plot(mean_rw_history)\n",
    "            plt.grid()\n",
    "\n",
    "            assert not np.isnan(td_loss_history[-1])\n",
    "            plt.subplot(1, 2, 2)\n",
    "            plt.title(\"TD loss history (smoothened)\")\n",
    "            plt.plot(smoothen(td_loss_history))\n",
    "            plt.grid()\n",
    "\n",
    "            plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setup Training Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setup some parameters for training\n",
    "timesteps_per_epoch = 1\n",
    "batch_size = 32\n",
    "total_steps = 3 * 10**4\n",
    "\n",
    "# set exploration epsilon \n",
    "start_epsilon = 1\n",
    "end_epsilon = 0.05\n",
    "eps_decay_final_step = 2 * 10**4\n",
    "\n",
    "# setup some frequency for logging and updating target network\n",
    "loss_freq = 50\n",
    "refresh_target_network_freq = 100\n",
    "eval_freq = 1000\n",
    "\n",
    "# to clip the gradients\n",
    "max_grad_norm = 5000\n",
    "\n",
    "#set up random numbers\n",
    "seed=0\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed) \n",
    "\n",
    "#init environment\n",
    "env_name = 'CartPole-v1'\n",
    "env = make_env(env_name)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "\n",
    "#init agent, target network and Optimizer\n",
    "agent = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())\n",
    "optimizer = torch.optim.Adam(agent.parameters(), lr=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000, epsilon = 0.05000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████| 30001/30001 [04:03<00:00, 123.05it/s]\n"
     ]
    }
   ],
   "source": [
    "train_agent(env, agent, target_network, optimizer, td_loss_fn=td_loss_dqn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final score: 126.0\n",
      "Well done\n"
     ]
    }
   ],
   "source": [
    "final_score = evaluate(\n",
    "  make_env(env_name),\n",
    "  agent, n_games=30, greedy=True, t_max=1000\n",
    ")\n",
    "print('final score:', final_score)\n",
    "print('Well done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Record and Play a video of trained agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let us record a video of trained agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper function to record videos\n",
    "def record_video(env_id, video_folder, video_length, agent):\n",
    "\n",
    "    vec_env = DummyVecEnv([lambda: gym.make(env_id, render_mode=\"rgb_array\")])\n",
    "    # Record the video starting at the first step\n",
    "    vec_env = VecVideoRecorder(vec_env, video_folder,\n",
    "                           record_video_trigger=lambda x: x == 0, video_length=video_length,\n",
    "                           name_prefix=f\"{type(agent).__name__}-{env_id}\")\n",
    "\n",
    "    obs = vec_env.reset()\n",
    "    for _ in range(video_length + 1):\n",
    "        action = agent.get_action(obs).detach().cpu().numpy()\n",
    "        obs, _, _, _ = vec_env.step(action)\n",
    "    # video filename\n",
    "    file_path = \"./\"+video_folder+vec_env.video_recorder.path.split(\"/\")[-1]\n",
    "    # Save the video\n",
    "    vec_env.close()\n",
    "    return file_path\n",
    "\n",
    "def play_video(file_path):\n",
    "    mp4 = open(file_path, 'rb').read()\n",
    "    data_url = \"data:video/mp4;base64,\" + b64encode(mp4).decode()\n",
    "    return HTML(\"\"\"\n",
    "        <video width=400 controls>\n",
    "              <source src=\"%s\" type=\"video/mp4\">\n",
    "        </video>\n",
    "        \"\"\" % data_url)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving video to /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_e/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "Moviepy - Building video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_e/DQNAgent-CartPole-v1-step-0-to-step-500.mp4.\n",
      "Moviepy - Writing video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_e/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                        \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_e/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=400 controls>\n",
       "              <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\">\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "video_folder = \"logs/7_e/\"\n",
    "video_length = 500\n",
    "\n",
    "video_file = record_video(env_name, video_folder, video_length, agent)\n",
    "\n",
    "play_video(video_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Categorical 51-Atom DQN (C-51)\n",
    "\n",
    "In the paper, https://arxiv.org/pdf/1707.06887.pdf , authors of the paper use a different route of distributional RL. Till now we have been outputting Q(s,a) values for an input state `s`. The number of units in output were of size `n_action`. In a way the output values were expected Q(s,a) using monte-carlo technique of averaging over a number of samples to form an estimate $\\hat Q(s,a)$ of the actual expected value $E[Q(s,a)]$. \n",
    "\n",
    "In Categorical 51-Atom DQN, for each Q(s,a) (`n_action` of them), we now produce an estimate of the distribution of Q(s,a) values - `n_atom` values for each q(s,a). We are now trying to predict the entire distribution modeled as a categorical probability distribution instead of just estimating the mean value of Q(s,a). \n",
    "\n",
    "$$ Q(s,a) = \\sum_i z_i p_i(s,a)$$ \n",
    "\n",
    "$p_i(s,a)$ is the probability that action-value at (s,a) will be $z_i$. \n",
    "\n",
    "We now have `n_action * n_atom` outputs, i.e. `n_atom` outputs for each value of `n_action`. Further these outputs are probabilities. For one action, we have `n_atom` probabilities and these are the probability of Q_value being in `-n_atom` discrete values in the range `V_min` to `V_max`. You can refer to the text or the linked paper above for more details. \n",
    "\n",
    "In C51 version of **distributional RL**, the authors took $i$ to be 51 atoms (support points) over the values -10 to 10. We will use the same setup in code below. As these values are parameterized in the code, you are welcomed to change these and explore the impact.\n",
    "\n",
    "After bellman updates are applied, the values shift and there is a step of **projection** to bring back the probability distribution of Q(s,a) to the support points of **atoms**. \n",
    "\n",
    "The loss is also replaced from mean squared error to cross-entropy error. The agent is trained using a epsilon-greedy policy, similar to DQN. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CategoricalDQN(nn.Module):\n",
    "    def __init__(self, state_shape, n_actions, n_atoms=51, Vmin=-10, Vmax=10, epsilon=0):\n",
    "        \n",
    "        super(CategoricalDQN, self).__init__()\n",
    "        self.epsilon = epsilon\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape        \n",
    "        state_dim = state_shape[0]\n",
    "        self.n_atoms = n_atoms\n",
    "        self.Vmin = Vmin\n",
    "        self.Vmax = Vmax\n",
    "        # a simple NN with state_dim as input vector (input is state s)\n",
    "        # and self.n_actions as output vector of logits of q(s, a)\n",
    "        self.fc1 = nn.Linear(state_dim, 64)\n",
    "        self.fc2 = nn.Linear(64, 128)\n",
    "        self.fc3 = nn.Linear(128, 32)\n",
    "        self.probs = nn.Linear(32, n_actions * n_atoms)\n",
    "        \n",
    "    def forward(self, state_t):\n",
    "        # pass the state at time t through the network to get Q(s,a)\n",
    "        x = F.relu(self.fc1(state_t))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = F.relu(self.fc3(x))\n",
    "        probs = F.softmax(self.probs(x).view(-1, self.n_actions, self.n_atoms), dim=-1)\n",
    "        return probs\n",
    "\n",
    "    def get_probs(self, states):\n",
    "        # input is an array of states in numpy and output is Qvals as numpy array\n",
    "        states = torch.tensor(states, device=device, dtype=torch.float32)\n",
    "        probs = self.forward(states)\n",
    "        return probs.data.cpu().numpy()\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        # input is an array of states in numpy and outout is Qvals as numpy array\n",
    "        states = torch.tensor(states, device=device, dtype=torch.float32)\n",
    "        probs = self.forward(states)\n",
    "        support = torch.linspace(self.Vmin, self.Vmax, self.n_atoms)\n",
    "        qvals = support * probs\n",
    "        qvals = qvals.sum(-1)\n",
    "        return qvals.data.cpu().numpy()\n",
    "    \n",
    "    def get_action(self, states):\n",
    "        states = torch.tensor(np.array(states), device=device, dtype=torch.float32)\n",
    "        probs = self.forward(states)\n",
    "        support = torch.linspace(self.Vmin, self.Vmax, self.n_atoms)\n",
    "        qvals = support * probs\n",
    "        qvals = qvals.sum(-1)\n",
    "        best_actions = qvals.argmax(axis=-1)\n",
    "        return best_actions\n",
    "\n",
    "    def sample_actions(self, qvalues):\n",
    "        # sample actions from a batch of q_values using epsilon greedy policy\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions = qvalues.shape\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        should_explore = np.random.choice(\n",
    "            [0, 1], batch_size, p=[1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_projection(model, next_states, rewards, done_flags, gamma=0.99, n_atoms=51, Vmin=-10, Vmax=10):\n",
    "    batch_size = next_states.size()[0]\n",
    "\n",
    "    d_z = (Vmax - Vmin) / (n_atoms-1)\n",
    "    support = torch.linspace(Vmin, Vmax, n_atoms)\n",
    "    probs = model(next_states)\n",
    "    qvals = support * probs\n",
    "    best_actions = qvals.sum(-1).argmax(-1)\n",
    "    best_actions = best_actions.unsqueeze(1).unsqueeze(1).expand(probs.size(0), 1, probs.size(2))\n",
    "    best_qvals = qvals.gather(1,best_actions).squeeze(1)\n",
    "    \n",
    "    rewards = rewards.unsqueeze(1).expand_as(best_qvals)\n",
    "    done_flags   = done_flags.unsqueeze(1).expand_as(best_qvals)\n",
    "    support = support.unsqueeze(0).expand_as(best_qvals)\n",
    "    \n",
    "    Tz = rewards + (1-done_flags) * gamma * support\n",
    "    Tz = Tz.clamp(Vmin, Vmax)\n",
    "    b = (Tz - Vmin) / (d_z)\n",
    "    l = b.floor().long()\n",
    "    u = b.ceil().long()\n",
    "    \n",
    "    projected_dist = torch.zeros(best_qvals.size())\n",
    "    \n",
    "    offset = torch.linspace(0, (batch_size - 1) * n_atoms, batch_size).long()\\\n",
    "                    .unsqueeze(1).expand(batch_size, n_atoms)\n",
    "\n",
    "    proj_dist = torch.zeros(best_qvals.size())    \n",
    "    proj_dist.view(-1).index_add_(0, (l + offset).view(-1), (best_qvals * (u.float() - b)).view(-1))\n",
    "    proj_dist.view(-1).index_add_(0, (u + offset).view(-1), (best_qvals * (b - l.float())).view(-1))\n",
    "    \n",
    "    return proj_dist  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def td_loss_categorical_dqn(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma=0.99, device=device):\n",
    "\n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, device=device, dtype=torch.float)\n",
    "    actions = torch.tensor(actions, device=device, dtype=torch.long)\n",
    "    rewards = torch.tensor(rewards, device=device, dtype=torch.float)\n",
    "    next_states = torch.tensor(next_states, device=device, dtype=torch.float)\n",
    "    done_flags = torch.tensor(done_flags.astype('float32'),device=device,dtype=torch.float)\n",
    "\n",
    "\n",
    "    dist = agent(states)\n",
    "    batch_size, n_actions, n_atoms = dist.size()\n",
    "    actions = actions.unsqueeze(1).unsqueeze(1).expand(batch_size, 1, n_atoms)\n",
    "    dist = dist.gather(1, actions).squeeze(1)\n",
    "    dist.clamp(0.01, 0.99)\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        proj_dist = compute_projection(target_network, next_states, rewards, done_flags, gamma)\n",
    "    \n",
    "    loss = - (proj_dist * dist.log()).sum(1).mean()\n",
    "        \n",
    "    return loss\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setup Training parameters and network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setup some parameters for training\n",
    "timesteps_per_epoch = 1\n",
    "batch_size = 32\n",
    "total_steps = 3 * 10**4\n",
    "\n",
    "# set exploration epsilon \n",
    "start_epsilon = 1\n",
    "end_epsilon = 0.05\n",
    "eps_decay_final_step = 2 * 10**4\n",
    "\n",
    "# setup frequency for logging and updating target network\n",
    "loss_freq = 50\n",
    "refresh_target_network_freq = 100\n",
    "eval_freq = 1000\n",
    "\n",
    "# to clip the gradients\n",
    "max_grad_norm = 5000\n",
    "\n",
    "#set up random numbers\n",
    "seed=0\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed) \n",
    "\n",
    "#init environment\n",
    "env_name = 'CartPole-v1'\n",
    "env = make_env(env_name)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "\n",
    "#init agent, target network and Optimizer\n",
    "agent = CategoricalDQN(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = CategoricalDQN(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())\n",
    "optimizer = torch.optim.Adam(agent.parameters(), lr=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000, epsilon = 0.05000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████| 30001/30001 [02:10<00:00, 229.65it/s]\n"
     ]
    }
   ],
   "source": [
    "train_agent(env, agent, target_network, optimizer, td_loss_fn=td_loss_categorical_dqn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final score(Noisy DQN): 217\n"
     ]
    }
   ],
   "source": [
    "final_score = evaluate(\n",
    "  make_env(env_name),\n",
    "  agent, n_games=30, greedy=True, t_max=1000\n",
    ")\n",
    "print('final score(Noisy DQN): {:.0f}'.format(final_score))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving video to /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_e/CategoricalDQN-CartPole-v1-step-0-to-step-500.mp4\n",
      "Moviepy - Building video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_e/CategoricalDQN-CartPole-v1-step-0-to-step-500.mp4.\n",
      "Moviepy - Writing video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_e/CategoricalDQN-CartPole-v1-step-0-to-step-500.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                        \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_e/CategoricalDQN-CartPole-v1-step-0-to-step-500.mp4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=400 controls>\n",
       "              <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\">\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "video_file = record_video(env_name, video_folder, video_length, agent)\n",
    "\n",
    "play_video(video_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n",
    "\n",
    "In this notebook we saw how to train a DQN agent with experience replay and target networks. We also saw first variant under distributional RL i.e. **Distributional RL - Categorical DQN specifically 51-Atom (C51)**\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
